/**
 * 工具验证函数
 */

/**
 * 验证手机号码格式
 * @param phone 手机号码
 * @returns 是否为有效的手机号码
 */
export function checkPhoneNumber(phone: string): boolean {
    if (!phone) return false
    const phoneRegex = /^1[3-9]\d{9}$/
    return phoneRegex.test(phone)
}

/**
 * 判断是否为空
 * @param value 要判断的值
 * @returns 是否为空
 */
export function isEmpty(value: any): boolean {
    if (value === null || value === undefined) {
        return true
    }

    if (typeof value === 'string') {
        return value.trim() === ''
    }

    if (Array.isArray(value)) {
        return value.length === 0
    }

    if (typeof value === 'object') {
        return Object.keys(value).length === 0
    }

    return false
}

/**
 * 防抖函数
 * @param func 要防抖的函数
 * @param wait 等待时间（毫秒）
 * @returns 防抖后的函数
 */
export function debounce<T extends (...args: any[]) => any>(
    func: T,
    wait: number
): (...args: Parameters<T>) => void {
    let timeout: NodeJS.Timeout | null = null

    return function executedFunction(...args: Parameters<T>) {
        const later = () => {
            timeout = null
            func(...args)
        }

        if (timeout) {
            clearTimeout(timeout)
        }
        timeout = setTimeout(later, wait)
    }
}

/**
 * 节流函数
 * @param func 要节流的函数
 * @param wait 等待时间（毫秒）
 * @returns 节流后的函数
 */
export function throttle<T extends (...args: any[]) => any>(
    func: T,
    wait: number
): (...args: Parameters<T>) => void {
    let inThrottle: boolean = false

    return function executedFunction(...args: Parameters<T>) {
        if (!inThrottle) {
            func(...args)
            inThrottle = true
            setTimeout(() => {
                inThrottle = false
            }, wait)
        }
    }
}

/**
 * 过滤对象中的空属性
 * @param obj 要过滤的对象
 * @returns 过滤后的对象
 */
export function filterObjectEmptyAttribute(obj: Record<string, any>): Record<string, any> {
    const result: Record<string, any> = {}

    for (const [key, value] of Object.entries(obj)) {
        if (!isEmpty(value)) {
            result[key] = value
        }
    }

    return result
}

/**
 * 处理数据分配函数
 * @param defaultValue 默认值
 * @param value 要处理的值
 * @returns 处理后的值
 */
export function dealAssignDataFunction<T>(defaultValue: T, value: any): T {
    if (isEmpty(value)) {
        return defaultValue
    }
    return value
}

/**
 * 格式化金额
 * @param amount 金额
 * @param decimals 小数位数
 * @returns 格式化后的金额字符串
 */
export function formatMoney(amount: number, decimals: number = 2): string {
    return amount.toFixed(decimals)
}

/**
 * 格式化日期
 * @param date 日期
 * @param format 格式字符串
 * @returns 格式化后的日期字符串
 */
export function formatDate(date: Date | string | number, format: string = 'YYYY-MM-DD'): string {
    const d = new Date(date)

    if (isNaN(d.getTime())) {
        return ''
    }

    const year = d.getFullYear()
    const month = String(d.getMonth() + 1).padStart(2, '0')
    const day = String(d.getDate()).padStart(2, '0')
    const hours = String(d.getHours()).padStart(2, '0')
    const minutes = String(d.getMinutes()).padStart(2, '0')
    const seconds = String(d.getSeconds()).padStart(2, '0')

    return format
        .replace('YYYY', String(year))
        .replace('MM', month)
        .replace('DD', day)
        .replace('HH', hours)
        .replace('mm', minutes)
        .replace('ss', seconds)
}

/**
 * 验证手机号
 * @param phone 手机号
 * @returns 是否有效
 */
export function validatePhone(phone: string): boolean {
    const phoneRegex = /^1[3-9]\d{9}$/
    return phoneRegex.test(phone)
}

/**
 * 验证邮箱
 * @param email 邮箱
 * @returns 是否有效
 */
export function validateEmail(email: string): boolean {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
    return emailRegex.test(email)
}

/**
 * 深拷贝对象
 * @param obj 要拷贝的对象
 * @returns 拷贝后的对象
 */
export function deepClone<T>(obj: T): T {
    if (obj === null || typeof obj !== 'object') {
        return obj
    }

    if (obj instanceof Date) {
        return new Date(obj.getTime()) as unknown as T
    }

    if (obj instanceof Array) {
        return obj.map(item => deepClone(item)) as unknown as T
    }

    if (typeof obj === 'object') {
        const clonedObj = {} as T
        for (const key in obj) {
            if (obj.hasOwnProperty(key)) {
                clonedObj[key] = deepClone(obj[key])
            }
        }
        return clonedObj
    }

    return obj
}

/**
 * 深度获取对象属性值
 * @param obj 要获取属性的对象
 * @param path 属性路径，用点号分隔
 * @param defaultValue 默认值
 * @returns 属性值或默认值
 */
export function fetchObjectDeepAttrValue(obj: any, path: string, defaultValue: any = ''): any {
    if (!obj || !path) return defaultValue

    const keys = path.split('.')
    let result = obj

    for (const key of keys) {
        if (result && typeof result === 'object' && key in result) {
            result = result[key]
        } else {
            return defaultValue
        }
    }

    return result !== undefined ? result : defaultValue
}

/**
 * 数字检查函数
 * @param val 要检查的字符串
 * @returns 如果是数字则返回原值，否则返回空字符串
 */
export function NumberCheck(val: string): string {
    const pattern = /^[0-9.]*$/
    return pattern.test(val) ? val : ''
}

/**
 * 表单验证函数
 * @param testForm 要验证的表单对象
 * @returns 是否有空值
 */
export function formTestFun(testForm: Record<string, any>): boolean {
    for (const key in testForm) {
        if (!testForm[key]) {
            return true
        }
    }
    return false
}


// 隐藏字符串中间五位数替换成符号" * "
export function hiddenPhoneNumber(val: string) {
    const phoneNumber = val ? String(val) : ''
    return phoneNumber.replace(/(\d{3})\d{4}(\d{3})/, '$1*****$2')
}

/**
 * 金额正则验证函数
 * @param val 要验证的金额字符串
 * @returns 是否为有效的金额格式
 */
export function moneyRegFunction(val: string): boolean {
    if (!val) return false
    // 验证是否为有效的数字格式，支持小数
    const moneyRegex = /^\d+(\.\d{1,2})?$/
    return moneyRegex.test(val)
}